#include "Water_collection_system.h"
pthread_mutex_t mutexl = PTHREAD_MUTEX_INITIALIZER; /*互斥锁*/
extern int g_stop_pump;
volatile WXT_MSG_ID pump__feedbdack = 0;
pump_system_feedbdack pump_feedbdack_cb = NULL; //反馈抽水进度回调函数地址
/***************************
*函数名： pin_level_high_or_low
*参数：   要检测的引脚号
*返回值   （int）1为低电平，-1为高电平
*功能：   检测电平是否发生变化
***************************/
int pin_level_high_or_low(int button_pin)
{
    if (digitalRead(button_pin) == LOW) // 检测到低电平
    {
        usleep(40000);                      // 延时190ms    销抖
        if (digitalRead(button_pin) == LOW) // 检测到低电平
        {
            return 1;
        }
    }
    else if (digitalRead(button_pin) == HIGH)
    {
        usleep(40000);                       // 延时190ms    销抖
        if (digitalRead(button_pin) == HIGH) // 检测到低电平
        {
            return -1;
        }
    }
    //usleep(20000);
    return 0;
}

int Water_level_sensor(int water_level)
{
    int water_i = 0;
    if (pin_level_high_or_low(water_level) == 1)
    {
        while (1)
        {
            if (pin_level_high_or_low(water_level) == 1)
            {
                water_i++;
                printf("water_i==%d\n", water_i);
                if (water_i >= 25) //25*(140ms+60ms)=5s
                {
                    return 1;
                }
            }
            else
            {
                water_i = 0;
                return -1;
            }
            usleep(140000);
        }
    }
}

/***************************
*函数名： Composite_drainage
*参数：  1. 控制内排水的继电器（ 控制抽水排水水箱的继电器） 
         2. 内排水的时间，单位秒
         3. 外排水的时间，单位秒
*返回值   （int）
*功能：   内外复合排水，把水管的水排干净，具体看实物理解
***************************/
int Composite_drainage(int solenoid_valve, int within_time, int outside_time)
{

    printf("开始内排水\n");
    digitalWrite(solenoid_valve, HIGH);                                                   //  控制内排水的继电器（             //（solenoid_valve电磁阀打开）
    Drain_the_water_from_the_pipe(WITHIN_REMOVE_PIMP_WATER, within_time, solenoid_valve); //6.排除内水管里的水

    //外水管模式
    printf("开始外排水\n");
    digitalWrite(solenoid_valve, LOW);                                                      //（solenoid_valve电磁阀关闭）
    Drain_the_water_from_the_pipe(OUTSIDE_REMOVE_PIMP_WATER, outside_time, solenoid_valve); //6.排除外水管里的水

    //转换为抽水模式
    if (Drain_time_handle(1) == -1)
    {
        return -1;
    }
    digitalWrite(RELAY_5, LOW); //关闭继电器5
    digitalWrite(RELAY_6, LOW); //关闭继电器5或6
    return 0;
}

/***************************
*函数名： Pump_water_to_the_bucket
*参数：   控制抽水排水水箱的继电器
*返回值   （int）
*功能：   开始抽水
***************************/
int Pump_water_to_the_bucket(int pump_relay)
{
    digitalWrite(pump_relay, HIGH); //打开抽水继电器（pump_relay对应电磁阀打开）

    //3通电磁阀抽水模式
    digitalWrite(RELAY_5, LOW);     //打开继电器5
    digitalWrite(RELAY_6, LOW);     //打开继电器6
    if (Drain_time_handle(1) == -1) //延迟1秒防止水管卡死
    {
        return -1;
    }
    digitalWrite(RELAY_7, HIGH); //打开继电器7（启动真空泵），开始抽水
    return 0;
}

/***************************
*函数名： Water_pipe_diving
*参数：   空
*返回值   （int）
*功能：   水管下潜
***************************/
int Water_pipe_diving()
{
    digitalWrite(RELAY_0, HIGH);
    digitalWrite(RELAY_1, LOW);
    return 0;
}

/***************************
*函数名： Water_pipe_down_to_50cm_depth
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  水管下到0.5米水深
***************************/
int Water_pipe_down_to_50cm_depth()
{

    if (!(g_stop_pump == RESET_PUMP_STSTEM))
    {
        printf("2.水管下到0.5米水深\n");
        Water_pipe_diving(); //水管下潜
        printf("pump_cmd==%d", START_PUMP_SUCC);
        pump_feedbdack(START_PUMP_SUCC); //开始抽水
    }

    int timeout_time = 0;

    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (pin_level_high_or_low(INFRARED_0) == 1) //等待红外信号为低(离开水管黑色位置)
        {
            printf("INFRARED_0====高电平\n");
            break;
        }

        timeout_time++;
        if (timeout_time >= GRAYSCALE_TIME_OUT * 20) //(190+100)*5=1000ms*GRAYSCALE_TIME_OUT=GRAYSCALE_TIME_OUT秒
        {
            printf("水管下潜0.5米时超时\n");
            g_stop_pump = STOP_PUMP_WATERB;
            printf("pump_cmd==%d\n", DECLINE_HALF_TIMEOUT);
            pump_feedbdack(DECLINE_HALF_TIMEOUT); //水管下潜0.5米时超时
            return -2;
        }

        usleep(10000); //防止cpu使用过高
    }
    timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (pin_level_high_or_low(INFRARED_0) == -1) //等待红外信号为高(水管黑色位置)
        {
            digitalWrite(RELAY_0, LOW); //水管到达指定位置关闭继电器
            printf("INFRARED_0====低电平\n");
            return 2;
        }

        timeout_time++;
        //printf("choshuiiajiang0.5==%d\n", timeout_time);
        if (timeout_time >= GRAYSCALE_TIME_OUT * 20)
        {
            printf("水管下潜0.5米时超时\n");
            g_stop_pump = STOP_PUMP_WATERB;
            printf("pump_cmd==%d", DECLINE_HALF_TIMEOUT);
            pump_feedbdack(DECLINE_HALF_TIMEOUT); //水管下潜0.5米时超时
            return -2;
        }
        usleep(10000);
    }
    return 0;
}

/***************************
*函数名： Drain_time_handle
*参数：   int  排水时间 
*返回值   0正常退出，-1为收到停止抽水信号
*功能：   在延迟中可被停止信号中断
***************************/
int Drain_time_handle(int drain_time)
{
    drain_time = drain_time * 100;
    while (drain_time--)
    {
        if (g_stop_pump == STOP_PUMP_WATERB || g_stop_pump == RESET_PUMP_STSTEM)
        {
            return -1;
        }
        usleep(10000);
    }
    return 0;
}
/***************************
*函数名： Drain_the_water_from_the_pipe
*参数：   int （参数为WITHIN_REMOVE_PIMP_WATER为内排水，为OUTSIDE_REMOVE_PIMP_WATER为外排水） int 排水时间 
*返回值   （int）
*功能：   控制继电器操作  排除水管里的水
***************************/
int Drain_the_water_from_the_pipe(int relay, int p_time, int pin_drainage)
{
    if (g_stop_pump == STOP_PUMP_WATERB || g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }

    if (relay == WITHIN_REMOVE_PIMP_WATER) //内排水
    {
        digitalWrite(RELAY_7, LOW); //关闭继电器7（关闭真空泵）
        // int pin_level = 0;
        // pin_level = Storage_pin_level(); //获取电平值临时保存

        //释放压力防止电磁阀堵塞
        digitalWrite(RELAY_2, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_3, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_4, HIGH); //  控制内排水的继电器

        if (Drain_time_handle(2) == -1) //延迟1秒防止水管卡死
        {
            return -1;
        }
        //内排水
        digitalWrite(RELAY_5, HIGH);
        digitalWrite(RELAY_6, LOW);
        if (Drain_time_handle(1) == -1) //延迟1秒防止水管卡死
        {
            return -1;
        }
        if (pin_drainage != 0) //不是第一次排水
        {
            //还原排水继电器
            digitalWrite(RELAY_2, LOW); //  控制内排水的继电器
            digitalWrite(RELAY_3, LOW); //  控制内排水的继电器
            digitalWrite(RELAY_4, LOW); //  控制内排水的继电器
            sleep(0.1);
            digitalWrite(pin_drainage, HIGH); //  控制内排水的继电器
        }

        // write_pin_level(pin_level);          //还原电平值
        digitalWrite(RELAY_7, HIGH);         //打开继电器7（启动真空泵开始排水）
        if (Drain_time_handle(p_time) == -1) //延迟p_time秒，在延迟中可被停止信号中断
        {
            return -1;
        }
        digitalWrite(RELAY_7, LOW);     //关闭继电器7（关闭真空泵）
        if (Drain_time_handle(1) == -1) //延迟p_time秒，在延迟中可被停止信号中断
        {
            return -1;
        }
    }
    else if (relay == OUTSIDE_REMOVE_PIMP_WATER) //外排水
    {
        digitalWrite(RELAY_7, LOW); //关闭继电器7（关闭真空泵）

        //释放压力防止电磁阀堵塞
        digitalWrite(RELAY_2, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_3, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_4, HIGH); //  控制内排水的继电器

        if (Drain_time_handle(2) == -1) //延迟1秒防止水管卡死
        {
            return -1;
        }
        //外排水
        digitalWrite(RELAY_5, HIGH);
        digitalWrite(RELAY_6, HIGH);
        if (Drain_time_handle(1) == -1) //延迟1秒防止水管卡死
        {
            return -1;
        }

        digitalWrite(RELAY_7, HIGH);         //打开继电器7（启动真空泵开始排水）
        if (Drain_time_handle(p_time) == -1) //延迟p_time秒，在延迟中可被停止信号中断
        {
            return -1;
        }
        digitalWrite(RELAY_7, LOW);     //关闭继电器7（关闭真空泵）
        if (Drain_time_handle(1) == -1) //延迟p_time秒，在延迟中可被停止信号中断
        {
            return -1;
        }
        //释放压力防止电磁阀堵塞
        digitalWrite(RELAY_2, LOW); //  控制内排水的继电器
        digitalWrite(RELAY_3, LOW); //  控制内排水的继电器
        digitalWrite(RELAY_4, LOW); //  控制内排水的继电器
    }
    else
    {
        printf("参数错误==%d\n", relay);
        return -2;
    }
    return 0;
}

/***************************
*函数名： Pump_to_50cm_bucket
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  抽水到0.5米水桶
***************************/
int Pump_to_50cm_bucket()
{
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("4抽水到0.5米水桶\n");
    Pump_water_to_the_bucket(RELAY_2); //开始抽水
    int timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (Water_level_sensor(WATER_LEVEL_0) == 1) //等待红外信号为低
        {

            printf("pump_cmd==%d", HALF_WATER_FINISH);
            pump_feedbdack(HALF_WATER_FINISH);                                                          //0.5m 抽水结束
            digitalWrite(RELAY_7, LOW);                                                                 //（关闭真空泵）
            Composite_drainage(RELAY_2, WITHIN_REMOVE_PIMP_WATER_TIME, OUTSIDE_REMOVE_PIMP_WATER_TIME); //内外复合排水
            printf("WATER_LEVEL_0====低电平\n");
            return 2;
        }
        timeout_time++;
        //printf("choshui0.5==%d\n", timeout_time);
        if (timeout_time >= BUCKET_TIME_OUT * 20)
        {
            printf("抽0.5水桶超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", HALF_WATER_TIMEOUT);
            pump_feedbdack(HALF_WATER_TIMEOUT); //抽0.5水桶超时
            return -2;
        }
        usleep(10000);
    }
    return 0;
}

/***************************
*函数名： Water_pipe_down_to_100cm_depth
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  水管下潜到1米深
***************************/
int Water_pipe_down_to_100cm_depth()
{
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("5.水管下潜到1米深\n");
    Water_pipe_diving(); //水管下潜
    int timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (pin_level_high_or_low(INFRARED_0) == 1) //等待红外信号为低(离开水管黑色位置)
        {
            printf("INFRARED_0====高电平\n");
            break;
        }
        timeout_time++;
        if (timeout_time >= GRAYSCALE_TIME_OUT * 20)
        {
            printf("水管下潜1米时超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", DECLINE_ONE_TIMEOUT);
            pump_feedbdack(DECLINE_ONE_TIMEOUT); //水管下潜1米时超时
            return -2;
        }

        usleep(10000);
    }
    timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (pin_level_high_or_low(INFRARED_0) == -1) //等待红外信号为高
        {
            digitalWrite(RELAY_0, LOW); //水管到达指定位置关闭继电器
            printf("INFRARED_0====低电平\n");

            printf("pump_cmd==%d", ONE_WATER_START);
            pump_feedbdack(ONE_WATER_START); //1m 抽水开始
            return 2;
        }

        timeout_time++;
        //printf("choshuiiajiang1.0==%d\n", timeout_time);
        if (timeout_time >= GRAYSCALE_TIME_OUT * 20)
        {
            printf("水管下潜1米时超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", DECLINE_ONE_TIMEOUT);
            pump_feedbdack(DECLINE_ONE_TIMEOUT); //水管下潜1米时超时
            return -2;
        }
        usleep(10000);
    }
    return 0;
}

/***************************
*函数名： Pump_to_100cm_bucket
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  抽水到1米水桶
***************************/
int Pump_to_100cm_bucket()
{
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("7.抽水到1米水桶\n");
    Pump_water_to_the_bucket(RELAY_3); //开始抽水
    int timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (Water_level_sensor(WATER_LEVEL_1) == 1) //等待红外信号为低
        {

            printf("pump_cmd==%d", ONE_WATER_FINISH);
            pump_feedbdack(ONE_WATER_FINISH);                                                           //1m 抽水结束
            Composite_drainage(RELAY_3, WITHIN_REMOVE_PIMP_WATER_TIME, OUTSIDE_REMOVE_PIMP_WATER_TIME); //内外复合排水
            printf("WATER_LEVEL_1====低电平\n");

            return 2;
        }
        timeout_time++;
        //printf("choshui1.0==%d\n", timeout_time);
        if (timeout_time >= BUCKET_TIME_OUT * 20) //120秒
        {
            printf("抽1水桶超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", ONE_WATER_TIMEOUT);
            pump_feedbdack(ONE_WATER_TIMEOUT); //抽1水桶超时
            return -2;
        }
        usleep(10000);
    }
    return 0;
}

/***************************
*函数名： Water_pipe_down_to_150cm_depth
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  水管下潜到1.5米深
***************************/
int Water_pipe_down_to_150cm_depth()
{
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("8.水管下潜到1.5米深\n");
    Water_pipe_diving(); //水管下潜
    int timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (pin_level_high_or_low(INFRARED_0) == 1) //等待红外信号为低(离开水管黑色位置)
        {
            printf("INFRARED_0====高电平\n");
            break;
        }

        timeout_time++;
        if (timeout_time >= GRAYSCALE_TIME_OUT * 40)
        {
            printf("水管下潜1.5米时超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", DECLINE_ONEHALF_TIMEOUT);
            pump_feedbdack(DECLINE_ONEHALF_TIMEOUT); //水管下潜1.5米时超时
            return -2;
        }
        usleep(10000);
    }
    timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (pin_level_high_or_low(INFRARED_0) == -1) //等待红外信号为高
        {
            digitalWrite(RELAY_0, LOW); //水管到达指定位置关闭继电器
            printf("INFRARED_0====低电平\n");

            printf("pump_cmd==%d", ONEHALF_WATER_START);
            pump_feedbdack(ONEHALF_WATER_START); //1.5m 抽水开始
            return 2;
        }

        timeout_time++;
        //printf("choshuiiajiang1.5==%d\n", timeout_time);
        if (timeout_time >= GRAYSCALE_TIME_OUT * 20)
        {
            printf("水管下潜1.5米时超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", DECLINE_ONEHALF_TIMEOUT);
            pump_feedbdack(DECLINE_ONEHALF_TIMEOUT); //水管下潜1.5米时超时
            return -2;
        }
        usleep(10000);
    }
    return 0;
}

/***************************
*函数名： Pump_to_150cm_bucket
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  抽水到1.5米水桶
***************************/
int Pump_to_150cm_bucket()
{
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("10.抽水到1.5米水桶\n");
    Pump_water_to_the_bucket(RELAY_4); //开始抽水
    int timeout_time = 0;
    while (!(g_stop_pump == RESET_PUMP_STSTEM) && (!(g_stop_pump == STOP_PUMP_WATERB)))
    {
        if (Water_level_sensor(WATER_LEVEL_2) == 1) //等待1.5水桶满触发的红外信号
        {

            printf("pump_cmd==%d", ONEHALF_WATER_FINISH);
            pump_feedbdack(ONEHALF_WATER_FINISH);                                                       //1.5m 抽水结束
            Composite_drainage(RELAY_4, WITHIN_REMOVE_PIMP_WATER_TIME, OUTSIDE_REMOVE_PIMP_WATER_TIME); //内外复合排水
            printf("WATER_LEVEL_2====低电平\n");
            return 2;
        }

        timeout_time++;
        //printf("choshui1.5==%d\n", timeout_time);
        if (timeout_time >= BUCKET_TIME_OUT * 20)
        {
            printf("抽1.5水桶超时\n");
            g_stop_pump = STOP_PUMP_WATERB;

            printf("pump_cmd==%d", ONEHALF_WATER_TIMEOUT);
            pump_feedbdack(ONEHALF_WATER_TIMEOUT); //抽1.5水桶超时
            return -2;
        }
        usleep(10000);
    }
    return 0;
}

/***************************
*函数名： Take_back_the_water_pipe_and_discharge_the_water_from_the_water_pipe
*参数：   空
*返回值   （int）
*功能：   控制继电器操作  收回水管且排出水管里的水
***************************/
int Water_pipg_recycling()
{
    printf("g000_stop_pump=%d", g_stop_pump);
    if (g_stop_pump == STOP_PUMP_WATERB)
    {
        g_stop_pump = 0;

        printf("pump_cmd==%d", STOP_PUMP_SUCC);
        pump_feedbdack(STOP_PUMP_SUCC); //停止成功
        printf("收到关闭抽水系统操作，直接回收水管退出\n");
    }
    if (!(g_stop_pump == RESET_PUMP_STSTEM))
    {
        //水管初始化
        Water_pipe_init();

        printf(" 11.收回水管且排出水管里的水 \n");
        digitalWrite(RELAY_2, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_3, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_4, HIGH); //  控制内排水的继电器
        digitalWrite(RELAY_7, LOW);  //关闭继电器7（关闭真空泵）
        sleep(1);
        //内排水
        digitalWrite(RELAY_5, HIGH);
        digitalWrite(RELAY_6, LOW);
        sleep(1);
        digitalWrite(RELAY_7, HIGH); //打开继电器7（启动真空泵开始排水）
        sleep(4);
        digitalWrite(RELAY_7, LOW); //关闭继电器7（关闭真空泵）
        sleep(1);
        printf("开始外排水\n");
        sleep(2);

        //外排水
        digitalWrite(RELAY_5, HIGH);
        digitalWrite(RELAY_6, HIGH);

        sleep(1);
        digitalWrite(RELAY_7, HIGH); //打开继电器7（启动真空泵开始排水）
        sleep(1);
        //水管回收
        digitalWrite(RELAY_0, LOW);
        digitalWrite(RELAY_1, HIGH);
        //等待两个红外传感器同时触发--水管已收回
        int delay_i = 0;
        while (!(g_stop_pump == RESET_PUMP_STSTEM) && !(pin_level_high_or_low(INFRARED_0) == -1 && pin_level_high_or_low(INFRARED_1) == -1))
        {
            if (delay_i >= 1200) //收管时间为1200*80ms
            {
                printf("pump_cmd==%d", PUMP_WATER_FINISH_TIMEOUT);
                pump_feedbdack(PUMP_WATER_FINISH_TIMEOUT); //硬件设备回收超时
                                                           //停止所有动作
                Pumping_system_init();
                printf("硬件设备回收超时\n");
                return -1;
            }
            delay_i++;
            if ((delay_i % 20) == 0)
            {
                printf("delay==%d\n", delay_i);
            }

            usleep(10000);
        }
        if (!(g_stop_pump == RESET_PUMP_STSTEM))
        {
            //停止所有动作
            Pumping_system_init();
            printf("水管已收回\n");
        }
    }
    printf("g_stop_pump=%d", g_stop_pump);
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        Water_pipe_reset();
    }
    else
    {
        printf("pump_cmd==%d", PUMP_WATER_FINISH);
        pump_feedbdack(PUMP_WATER_FINISH); //硬件设备回收完成
    }
    return 0;
}

//第一次排水
int First_drainage()
{
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("第一次排水\n");
    //打开3个水桶的电磁阀
    digitalWrite(RELAY_2, HIGH);
    digitalWrite(RELAY_3, HIGH);
    digitalWrite(RELAY_4, HIGH);
    if (Drain_the_water_from_the_pipe(WITHIN_REMOVE_PIMP_WATER, 4, 0) == -1) //3.排除内水管里的水
    {
        return -1;
    }
    //关闭3个水桶的电磁阀
    digitalWrite(RELAY_2, LOW);
    digitalWrite(RELAY_3, LOW);
    digitalWrite(RELAY_4, LOW);
    if (Drain_the_water_from_the_pipe(OUTSIDE_REMOVE_PIMP_WATER, 5, 0) == -1) //3.排除外水管里的水
    {
        return -1;
    }
    if (g_stop_pump == RESET_PUMP_STSTEM)
    {
        return -1;
    }
    printf("pump_cmd==%d", HALF_WATER_START);
    pump_feedbdack(HALF_WATER_START); //0.5m 抽水开始
    return 0;
}

void pump_feedbdack(WXT_MSG_ID pump_feedback_cmd)
{
    pthread_mutex_lock(&mutexl); //互斥锁加锁
    pump__feedbdack = pump_feedback_cmd;
    if (pump_feedback_cmd == DECLINE_HALF_TIMEOUT || pump_feedback_cmd == DECLINE_ONE_TIMEOUT || pump_feedback_cmd == DECLINE_ONEHALF_TIMEOUT || pump_feedback_cmd == HALF_WATER_TIMEOUT || pump_feedback_cmd == ONE_WATER_TIMEOUT || pump_feedback_cmd == ONEHALF_WATER_TIMEOUT)
    {
        pump_feedbdack_cb(pump__feedbdack, sizeof(WXT_MSG_ID), PUMP_CMD);
    }
    pthread_mutex_unlock(&mutexl); ////互斥锁解锁
}
/************************************************************************************
*函数名： pump_feedback_send
*参数：   void* 函数指针 
*返回值   无
*功能：   循环发送反馈，不判断上位机是否接收，相同反馈1秒发送一次，反馈不同时100ms内发送反馈，提高实时性
*****************************************************************************************/
void *pump_feedback_send(void *arg)
{
    pthread_detach(pthread_self()); //线程分离
    pump_feedbdack_cb = (pump_system_feedbdack)arg;
    if (pump_feedbdack_cb == NULL)
    {
        printf("回调地址为空  pump_system_feedbdack\n");
    }
    WXT_MSG_ID pump_f_feedbdack = 0;
    int delay_i = 0;

    while (1)
    {
        pthread_mutex_lock(&mutexl); //互斥锁加锁
        if (g_stop_pump == RECOVERY_PIPE_FINISH)
            pump__feedbdack = 0;

        if (pump_f_feedbdack == pump__feedbdack)
        {
            delay_i++;
        }
        else
        {
            printf("1回调给用户层  pump__feedbdack=%d\n", pump__feedbdack);
            pump_feedbdack_cb(pump__feedbdack, sizeof(WXT_MSG_ID), PUMP_CMD);
            pump_f_feedbdack = pump__feedbdack;
        }
        if (delay_i >= 10)
        {
            printf("2回调给用户层  pump__feedbdack=%d\n", pump__feedbdack);
            pump_feedbdack_cb(pump__feedbdack, sizeof(WXT_MSG_ID), PUMP_CMD);
            delay_i = 0;
        }
        pthread_mutex_unlock(&mutexl); ////互斥锁解锁
        usleep(100000);
    }
}

void Water_pipe_init()
{
    //水管初始化
    digitalWrite(RELAY_0, LOW);
    digitalWrite(RELAY_1, LOW);
}

void Pumping_system_init()
{
    digitalWrite(RELAY_0, LOW);
    digitalWrite(RELAY_1, LOW);
    digitalWrite(RELAY_2, LOW);
    digitalWrite(RELAY_3, LOW);
    digitalWrite(RELAY_4, LOW);
    digitalWrite(RELAY_5, LOW);
    digitalWrite(RELAY_6, LOW);
    digitalWrite(RELAY_7, LOW);
}

int Water_pipe_reset()
{
    Water_pipe_init();
    printf(" 11.抽水重置 \n");
    digitalWrite(RELAY_2, HIGH); //  控制内排水的继电器
    digitalWrite(RELAY_3, HIGH); //  控制内排水的继电器
    digitalWrite(RELAY_4, HIGH); //  控制内排水的继电器
    digitalWrite(RELAY_7, LOW);  //关闭继电器7（关闭真空泵）
    sleep(1);
    //内排水
    digitalWrite(RELAY_5, HIGH);
    digitalWrite(RELAY_6, LOW);
    sleep(1);
    digitalWrite(RELAY_7, HIGH); //打开继电器7（启动真空泵开始排水）
    sleep(4);
    digitalWrite(RELAY_7, LOW); //关闭继电器7（关闭真空泵）
    sleep(1);
    printf("开始外排水\n");
    sleep(2);

    //外排水
    digitalWrite(RELAY_5, HIGH);
    digitalWrite(RELAY_6, HIGH);

    sleep(1);
    digitalWrite(RELAY_7, HIGH); //打开继电器7（启动真空泵开始排水）
    sleep(1);

    //水管下潜
    digitalWrite(RELAY_0, HIGH);
    digitalWrite(RELAY_1, LOW);
    sleep(4); //下潜4秒
    //水管回收
    digitalWrite(RELAY_0, LOW);
    digitalWrite(RELAY_1, HIGH);
    //等待两个红外传感器同时触发--水管已收回
    int delay_i = 0;
    while (!(pin_level_high_or_low(INFRARED_0) == -1 && pin_level_high_or_low(INFRARED_1) == -1))
    {
        if (delay_i >= 940) //收管时间为880*80ms
        {
            printf("pump_cmd==%d", RESET_PUMP_FAIL);
            pump_feedbdack(RESET_PUMP_FAIL); //硬件设备回收超时
                                             //停止所有动作
            Pumping_system_init();
            printf("水管重置失败\n");
            return -1;
        }
        delay_i++;
        if ((delay_i % 20) == 0)
        {
            printf("delay==%d\n", delay_i);
        }

        usleep(10000);
    }
    //停止所有动作
    Pumping_system_init();
    printf("水管重置成功\n");
    printf("pump_cmd==%d", RESET_PUMP_SUCCESS);
    pump_feedbdack(RESET_PUMP_SUCCESS); //水管重置成功
    sleep(4);
    pump_feedbdack(0);
    return 0;
}

/***************************/ //
//水质采样线程
/***************************/ //
void *water_sampling(void *arg)
{
    pthread_detach(pthread_self()); //线程分离

    pthread_t pump_feedback_id; //水采样线程id
    if ((pthread_create(&pump_feedback_id, NULL, pump_feedback_send, arg)) == -1)
    {
        printf("创建采水反馈线程错误!\n");
    }

    while (1)
    {
        if (g_stop_pump == START_PUMP_WATER || g_stop_pump == RESET_PUMP_STSTEM) //开始信号
        {
            printf("g_stop_pump == START_PUMP_WATER---%d\n", g_stop_pump);

            Water_pipe_down_to_50cm_depth();  //2.水管下到0.5米水深
            First_drainage();                 //3.第一次排水
            Pump_to_50cm_bucket();            //4.抽水到0.5米水桶
            Water_pipe_down_to_100cm_depth(); //5.水管下潜到1米深
            Pump_to_100cm_bucket();           //7.抽水到1米水桶
            Water_pipe_down_to_150cm_depth(); //8.水管下潜到1.5米深
            Pump_to_150cm_bucket();           //10.抽水到1.5米水桶
            Water_pipg_recycling();           //11.收回水管且排出水管里的水
            printf(" 完成 \n");
            g_stop_pump = 0;
        }
        usleep(1000000);
    }
}
